+# Serialize arguments before locking
+original_recursion_limit = sys.getrecursionlimit()
+sys.setrecursionlimit(10000)
+arguments_copy = dict(arguments.items())
+if class_name and code.co_name == "__init__" and "self" in arguments_copy:
+    del arguments_copy["self"]
+try:
+    local_vars = pickle.dumps(arguments_copy, protocol=pickle.HIGHEST_PROTOCOL)
+except (TypeError, pickle.PicklingError, AttributeError, RecursionError, OSError):
+    try:
+        local_vars = dill.dumps(arguments_copy, protocol=dill.HIGHEST_PROTOCOL)
+    except (TypeError, dill.PicklingError, AttributeError, RecursionError, OSError):
+        self.function_count[function_qualified_name] -= 1
+        sys.setrecursionlimit(original_recursion_limit)
+        return
+sys.setrecursionlimit(original_recursion_limit)
+
 with self._db_lock:
-    # Check connection again inside lock, in case __exit__ closed it.
     if self.con is None:
         return
-
     cur = self.con.cursor()
-
-    t_ns = time.perf_counter_ns()
-    original_recursion_limit = sys.getrecursionlimit()
-    try:
-        # pickling can be a recursive operator, so we need to increase the recursion limit
-        sys.setrecursionlimit(10000)
-        # We do not pickle self for __init__ to avoid recursion errors, and instead instantiate its class
-        # directly with the rest of the arguments in the replay tests. We copy the arguments to avoid memory
-        # leaks, bad references or side effects when unpickling.
-        arguments_copy = dict(arguments.items())  # Use the local 'arguments' from frame.f_locals
-        if class_name and code.co_name == "__init__" and "self" in arguments_copy:
-            del arguments_copy["self"]
-        local_vars = pickle.dumps(arguments_copy, protocol=pickle.HIGHEST_PROTOCOL)
-        sys.setrecursionlimit(original_recursion_limit)
-    except (TypeError, pickle.PicklingError, AttributeError, RecursionError, OSError):
-        # we retry with dill if pickle fails. It's slower but more comprehensive
-        try:
-            sys.setrecursionlimit(10000)  # Ensure limit is high for dill too
-            # arguments_copy should be used here as well if defined above
-            local_vars = dill.dumps(
-                arguments_copy if "arguments_copy" in locals() else dict(arguments.items()),
-                protocol=dill.HIGHEST_PROTOCOL,
-            )
-            sys.setrecursionlimit(original_recursion_limit)
-        except (TypeError, dill.PicklingError, AttributeError, RecursionError, OSError):
-            self.function_count[function_qualified_name] -= 1
-            return
     cur.execute(
         "INSERT INTO function_calls VALUES(?, ?, ?, ?, ?, ?, ?, ?)",
         (
             event,
             code.co_name,
             class_name,
             str(file_name),
             frame.f_lineno,
             frame.f_back.__hash__(),
-            t_ns,
+            time.perf_counter_ns(),
             local_vars,
         ),
     )
     self.trace_count += 1
     self.next_insert -= 1
     if self.next_insert == 0:
         self.next_insert = 1000
         self.con.commit()

-stack = [function_node]
+stack = list(function_node.body)
 while stack:
     node = stack.pop()
     if isinstance(node, ast.Return):
         return True
+    # skip nested function/class definitions
+    if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
+        continue
     stack.extend(ast.iter_child_nodes(node))
 return False

+# end of tracing: commit pending tracer_logic
+self.con.commit()
+
+# perform stats and printing outside lock
+console.rule("Codeflash: Traced Program Output End", style="bold blue")
+self.create_stats()
+self.make_pstats_compatible()
+self.print_stats("tottime")
+
 with self._db_lock:
     if self.con is None:
         return
-
-    self.con.commit()  # Commit any pending from tracer_logic
-    console.rule("Codeflash: Traced Program Output End", style="bold blue")
-    self.create_stats()  # This calls snapshot_stats which uses self.timings
-
     cur = self.con.cursor()
     cur.execute(
         "CREATE TABLE pstats (filename TEXT, line_number INTEGER, function TEXT, class_name TEXT, "
         "call_count_nonrecursive INTEGER, num_callers INTEGER, total_time_ns INTEGER, "
         "cumulative_time_ns INTEGER, callers BLOB)"
     )
     for func, (cc, nc, tt, ct, callers) in self.stats.items():
         remapped_callers = [{"key": k, "value": v} for k, v in callers.items()]
         cur.execute(
             "INSERT INTO pstats VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
             (
                 str(Path(func[0]).resolve()),
                 func[1],
                 func[2],
                 func[3],
                 cc,
                 nc,
                 tt,
                 ct,
                 json.dumps(remapped_callers),
             ),
         )
     self.con.commit()
-
-    self.make_pstats_compatible()  # Modifies self.stats and self.timings in-memory
-    self.print_stats("tottime")  # Uses self.stats, prints to console
-
-    cur = self.con.cursor()  # New cursor
     cur.execute("CREATE TABLE total_time (time_ns INTEGER)")
     cur.execute("INSERT INTO total_time VALUES (?)", (self.total_tt,))
     self.con.commit()
     self.con.close()
-    self.con = None  # Mark connection as closed
+    self.con = None

-if None is not self.timeout and (time.time() - self.start_time) > self.timeout:
+if self.timeout is not None and (time.time() - self.start_time) > self.timeout:
     sys.setprofile(None)
     threading.setprofile(None)
     console.print(f"Codeflash: Timeout reached! Stopping tracing at {self.timeout} seconds.")
     return